package manager.goods.service.impl;
import common.PageView;
import common.SnowflakeIdWorker;
import manager.brand.dao.BrandDao;
import manager.brand.vo.BrandVO;
import manager.categories.dao.CategoryDao;
import manager.categories.vo.CategoryVO;
import manager.goods.dao.SkuDao;
import manager.goods.dao.SpuDao;
import manager.goods.dao.SpuDetialDao;
import manager.goods.dao.StockDao;
import manager.goods.service.GoodsService;
import manager.goods.vo.*;
import manager.search.repository.GoodsRepository;
import manager.search.service.SearchService;
import org.springframework.amqp.core.*;
import org.springframework.amqp.core.Queue;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import tk.mybatis.mapper.entity.Example;
import java.util.*;
import java.util.stream.Collectors;
@Service(value = "goodsService")
public class GoodsServiceImpl implements GoodsService {
    @Autowired
    private SkuDao skuDao;
    @Autowired
    private SpuDao spuDao;
    @Autowired
    private SpuDetialDao spuDetialDao;
    @Autowired
    private StockDao stockDao;
    @Autowired
    private CategoryDao categoryDao;
    @Autowired
    private BrandDao brandDao;
    @Autowired
    private SearchService searchService;
    @Autowired
    private GoodsRepository goodsRepository;
    @Autowired
    private AmqpTemplate amqpTemplate;
    @Autowired
    private AmqpAdmin amqpAdmin;
    @Override
    public PageView<List<SpuVO>> selectByConditionPage(SpuVO spuVO) {
         return getPageDataFromDb(spuVO);
    }
    /**
     * 将MySQL的数据导入到ES中
     * @param spuVO
     * @return
     */
    private PageView<List<SpuVO>> getPageDataFromDb(SpuVO spuVO){
        PageView<List<SpuVO>> pageVO=new PageView<>();
        List<SpuVO> spus=spuDao.selectByConditionPage(spuVO);
        int count=spuDao.selectByConditionCount(spuVO);
        //组装分类数据
        List<String> categoryIds= spus.stream().map(SpuVO::getCategoryId).distinct().collect(Collectors.toList());
        List<String> brandIds=spus.stream().map(SpuVO::getBrandId).distinct().collect(Collectors.toList());
        List<String> spuIds=spus.stream().map(SpuVO::getId).distinct().collect(Collectors.toList());
        SkuVO skuVO=new SkuVO();
        skuVO.setSpuIds(spuIds);
        if(spuIds.size()>0){
            List<Long> spuLongIds=spuIds.stream().map(item->Long.parseLong(item)).collect(Collectors.toList());
            List<SkuVO> skus=skuDao.selectByCondition(skuVO);
            List<String> skuIds=skus.stream().map(item-> item.getId()).collect(Collectors.toList());
            Example example = new Example(StockVO.class);
            Example.Criteria criteria = example.createCriteria();
            criteria.andIn("skuId",skuIds);
            List<StockVO> stockList=stockDao.selectByExample(example);
            spus.forEach(item->{
                List<SkuVO> curSkus=skus.stream().filter(sku->sku.getSpuId().equals(item.getId())).collect(Collectors.toList());
                curSkus.forEach(skuItem->{
                     StockVO stockVO=stockList.stream().filter(stockItem->stockItem.getSkuId().equals(skuItem.getId())).findAny().get();
                     skuItem.setStockVO(stockVO);
                });
                item.setSkus(curSkus);
            });
            //查询分类和品牌
            CategoryVO spuVOCondition=new CategoryVO();
            Object[] ids=  categoryIds.toArray();
            Object[] brands=  brandIds.toArray();
            spuVOCondition.setIds(ids);
            List<CategoryVO> categories=categoryDao.selectByCondition(spuVOCondition);
            BrandVO brandVO=new BrandVO();
            brandVO.setIds(brands);
            List<BrandVO> brandResults=brandDao.selectByIds(brandVO);
            //将结果转成map
            //获取品牌信息
            Map categoryMap=new HashMap();
            Map brandMap=new HashMap();
            categories.forEach(item->{
                categoryMap.put(item.getId(),item.getName());
            });
            brandResults.forEach(item->{
                brandMap.put(item.getId(),item.getName());
            });
            List<SpuDetialVO> detialList=spuDetialDao.selectBySpuIds(spuLongIds);
            spus.forEach(item->{
                if(null!=categoryMap.get(item.getCategoryId())){
                    item.setCategoryName(categoryMap.get(item.getCategoryId()).toString());
                }
                if(null!=brandMap.get(item.getBrandId())){
                    item.setBrandName(brandMap.get(item.getBrandId()).toString());
                }
                List<SpuDetialVO> detialItemList=detialList.stream().filter(detial->detial.getSpuId().equals(item.getId())).collect(Collectors.toList());
                if(detialItemList.size()>0){
                    item.setSpuDetialVO(detialItemList.get(0));
                }
            });
        }
        pageVO.setRows(spus);
        pageVO.setTotal(count);
        return pageVO;
    }
    /**
     * 查询商品
     * @param spuVO
     * @return
     */
    @Override
    public SpuVO selectByCondition(SpuVO spuVO) {
         List<SpuVO> spus=spuDao.selectByCondition(spuVO);
         SpuVO spu=spus.get(0);
         CategoryVO categoryVO=new CategoryVO();
         Object[] ids=new Object[3];
         ids[0]=spu.getCategoryId();
         categoryVO.setIds(ids);
         List<CategoryVO> categoryVOList= categoryDao.selectByCondition(categoryVO);
         Map<Object, String> categoryMap=categoryVOList.stream().collect(Collectors.toMap(CategoryVO::getId,CategoryVO::getName));
         spu.setCategoryName(categoryMap.get(spu.getCategoryId()));
         //查询品牌
         BrandVO brandVO=new BrandVO();
         brandVO.setId(spu.getBrandId());
         List<BrandVO> brandItemList=brandDao.selectByCondition(brandVO);
         if(brandItemList.size()>0){
             spu.setBrandName(brandItemList.get(0).getName());
         }
         List<Long> spuIds=new ArrayList<Long>();
         spuIds.add(Long.valueOf(spu.getId()));
         List<SpuDetialVO> spuDetials=spuDetialDao.selectBySpuIds(spuIds);
         if(spuDetials.size()==0){
             return spu;
         }
         SpuDetialVO spuDetialVO=spuDetials.get(0);
         spu.setSpuDetialVO(spuDetialVO);
        //查询sku信息
         SkuVO skuVO=new SkuVO();
         skuVO.setSpuId(spu.getId());
         List<SkuVO> skus=skuDao.selectByCondition(skuVO);
         //查询库存信息
         Object skuIds[]=skus.stream().map(SkuVO::getId).toArray();
         StockVO stockVO=new StockVO();
         stockVO.setSkuIds(skuIds);
         List<StockVO> stocks=stockDao.selectByCondition(stockVO);
         Map<String,StockVO> stockMap=stocks.stream().collect(Collectors.toMap(StockVO::getSkuId,StockVO->StockVO));
         skus.forEach(item->{
             if(null!=stockMap.get(item.getId())){
                 item.setStockVO(stockMap.get(item.getId()));
             }
         });
         spu.setSkus(skus);
         return spu;
    }

    /**
     * 添加商品
     * @param spuVO
     */
    @Transactional
    @Override
    public void addGood(SpuVO spuVO) {
        //保存spu信息
         SnowflakeIdWorker idWorker = new SnowflakeIdWorker(0, 0);
         Long spuId=idWorker.nextId();
         String spuStrId=spuId.toString();
         spuVO.setId(spuStrId);
         spuVO.setCreateTime(new Date());
         spuVO.setLastUpdateTime(new Date());
         spuDao.saveSpu(spuVO);
         SpuDetialVO spuDetialVO=spuVO.getSpuDetialVO();
         spuDetialVO.setSpuId(spuStrId);
         spuDetialDao.saveSpuDetial(spuVO.getSpuDetialVO());
        //保存sku信息
         List<SkuVO> skus=spuVO.getSkus();
         List<StockVO> stocks=new ArrayList<StockVO>();
         skus.forEach(item->{
             String skuId=String.valueOf(idWorker.nextId());
             item.setId(skuId);
             item.setCreateTime(new Date());
             item.setLastUpdateTime(new Date());
             item.setSpuId(spuStrId);
             StockVO stockVO=item.getStockVO();
             stockVO.setSkuId(skuId);
             stockVO.setSeckillStock("0");
             stockVO.setSeckillTotal("0");
             stocks.add(stockVO);
        });
         skuDao.saveSkus(skus);
         stockDao.saveStocks(stocks);
    }

    /**
     * 修改商品
     * @param spuVO
     */
    @Transactional
    @Override
    public void updateGood(SpuVO spuVO) {
            spuVO.setLastUpdateTime(new Date());
            spuDao.updateSpu(spuVO);
            SpuDetialVO spuDetialVO=spuVO.getSpuDetialVO();
            spuDetialVO.setSpuId(spuVO.getId());
            spuDetialDao.updateSpuDetial(spuDetialVO);
            //删除sku
            SkuVO skuVO=new SkuVO();
            skuVO.setSpuId(spuVO.getId());
            List<SkuVO> skuList=skuDao.selectByCondition(skuVO);
            List<String> skuIds=skuList.stream().map(SkuVO::getId).collect(Collectors.toList());
            SkuVO newSkuVO=new SkuVO();
            newSkuVO.setSpuId(spuVO.getId());
            skuDao.deleteSkuBySpuId(newSkuVO);
            if(skuIds.size()>0){
                stockDao.deleteStock(skuIds);
            }
            //删除库存
            List<SkuVO> skus=spuVO.getSkus();
            List<StockVO> stocks=new ArrayList<StockVO>();
            SnowflakeIdWorker idWorker = new SnowflakeIdWorker(0, 0);
            skus.forEach(item->{
                item.setCreateTime(new Date());
                item.setLastUpdateTime(new Date());
                String skuId=String.valueOf(idWorker.nextId());
                item.setId(skuId);
                item.setSpuId(spuVO.getId());
                StockVO stockVO=item.getStockVO();
                stockVO.setSkuId(skuId);
                stockVO.setSeckillStock("0");
                stockVO.setSeckillTotal("0");
                stocks.add(stockVO);
            });
            skuDao.saveSkus(skus);
            stockDao.saveStocks(stocks);
            //同步商品到ES中
            saveGoodsToES(spuVO);
    }
    private void saveGoodsToES(SpuVO spuVO){
            searchService.saveDbToEs(spuVO);
    }
    /**
     * 删除商品
     * @param ids
     */
    @Transactional
    @Override
    public void deleteGoods(List<String> ids) {
        //删除spu
        spuDao.deleteSpus(ids);
        //删除spu详情
        spuDetialDao.deleteySpuIds(ids);
        //根据spu查询sku
        SkuVO skuVO=new SkuVO();
        skuVO.setSpuIds(ids);
        List<SkuVO> skus=skuDao.selectByCondition(skuVO);
        List<String> idsList=skus.stream().map(SkuVO::getId).collect(Collectors.toList());
        if(idsList.size()>0){
            skuDao.deleteSkuBySkuIds(idsList);
            stockDao.deleteStock(idsList);
        }
        List<SpuImageLogVO> imageLogVOS=new ArrayList<>();
        ids.forEach(id->{
            goodsRepository.deleteById(id);
            SpuImageLogVO spuImageLogVO=new SpuImageLogVO();
            spuImageLogVO.setSpuId(id);
            imageLogVOS.add(spuImageLogVO);
        });
        amqpAdmin.declareExchange(new DirectExchange("crmshop.images.exchange"));
        amqpAdmin.declareQueue(new Queue("crmshop.images.queen",true));
        amqpAdmin.declareBinding(new Binding("crmshop.images.queen", Binding.DestinationType.QUEUE,"crmshop.images.exchange","crmshop.images.delete",null));
        amqpTemplate.convertAndSend("crmshop.images.exchange", "crmshop.images.delete", imageLogVOS);
    }

    /**
     * 修改库存
     * @param skuList
     */
    @Override
    public void updateStock(List<Map<String, String>> skuList) {
//        skuList.forEach(item->{
//             StockVO stockVO=new StockVO();
//             stockVO.setSkuId(item.get("skuId"));
//             stockVO.setStock(Integer.parseInt(item.get("num")));
//             stockDao.updateStockByQty(stockVO);
//        });
    }

}
